/*
    * Copyright (C) 2007 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.google.common.base;
  
  import static com.google.common.testing.SerializableTester.reserialize;
  
  import com.google.common.annotations.GwtCompatible;
  import com.google.common.annotations.GwtIncompatible;
  import com.google.common.collect.Lists;
  import com.google.common.testing.ClassSanityTester;
  import com.google.common.testing.EqualsTester;
  
  import junit.framework.TestCase;
  
  import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.TimeoutException;
  import java.util.concurrent.atomic.AtomicInteger;
  import java.util.concurrent.atomic.AtomicReference;
  
  /**
   * Tests com.google.common.base.Suppliers.
   *
   * @author Laurence Gonsalves
   * @author Harry Heymann
   */
  @GwtCompatible(emulated = true)
  public class SuppliersTest extends TestCase {
    public void testCompose() {
      Supplier<Integer> fiveSupplier = new Supplier<Integer>() {
        @Override
        public Integer get() {
          return 5;
        }
      };
  
      Function<Number, Integer> intValueFunction =
          new Function<Number, Integer>() {
            @Override
            public Integer apply(Number x) {
              return x.intValue();
            }
          };
  
      Supplier<Integer> squareSupplier = Suppliers.compose(intValueFunction,
          fiveSupplier);
  
      assertEquals(Integer.valueOf(5), squareSupplier.get());
    }
  
    public void testComposeWithLists() {
      Supplier<ArrayList<Integer>> listSupplier
          = new Supplier<ArrayList<Integer>>() {
        @Override
        public ArrayList<Integer> get() {
          return Lists.newArrayList(0);
        }
      };
  
      Function<List<Integer>, List<Integer>> addElementFunction =
          new Function<List<Integer>, List<Integer>>() {
            @Override
            public List<Integer> apply(List<Integer> list) {
              ArrayList<Integer> result = Lists.newArrayList(list);
              result.add(1);
              return result;
            }
          };
  
      Supplier<List<Integer>> addSupplier = Suppliers.compose(addElementFunction,
          listSupplier);
  
      List<Integer> result = addSupplier.get();
      assertEquals(Integer.valueOf(0), result.get(0));
      assertEquals(Integer.valueOf(1), result.get(1));
    }
  
    static class CountingSupplier implements Supplier<Integer>, Serializable {
      private static final long serialVersionUID = 0L;
      transient int calls = 0;
      @Override
      public Integer get() {
        calls++;
       return calls * 10;
     }
   }
 
   public void testMemoize() {
     CountingSupplier countingSupplier = new CountingSupplier();
     Supplier<Integer> memoizedSupplier = Suppliers.memoize(countingSupplier);
     checkMemoize(countingSupplier, memoizedSupplier);
   }
 
   public void testMemoize_redudantly() {
     CountingSupplier countingSupplier = new CountingSupplier();
     Supplier<Integer> memoizedSupplier = Suppliers.memoize(countingSupplier);
     assertSame(memoizedSupplier, Suppliers.memoize(memoizedSupplier));
   }
 
   @GwtIncompatible("SerializableTester")
   public void testMemoizeSerialized() {
     CountingSupplier countingSupplier = new CountingSupplier();
     Supplier<Integer> memoizedSupplier = Suppliers.memoize(countingSupplier);
     checkMemoize(countingSupplier, memoizedSupplier);
     // Calls to the original memoized supplier shouldn't affect its copy.
     memoizedSupplier.get();
 
     Supplier<Integer> copy = reserialize(memoizedSupplier);
     memoizedSupplier.get();
 
     CountingSupplier countingCopy = (CountingSupplier)
         ((Suppliers.MemoizingSupplier<Integer>) copy).delegate;
     checkMemoize(countingCopy, copy);
   }
 
   private void checkMemoize(
       CountingSupplier countingSupplier, Supplier<Integer> memoizedSupplier) {
     // the underlying supplier hasn't executed yet
     assertEquals(0, countingSupplier.calls);
 
     assertEquals(10, (int) memoizedSupplier.get());
 
     // now it has
     assertEquals(1, countingSupplier.calls);
 
     assertEquals(10, (int) memoizedSupplier.get());
 
     // it still should only have executed once due to memoization
     assertEquals(1, countingSupplier.calls);
   }
 
   public void testMemoizeExceptionThrown() {
     Supplier<Integer> exceptingSupplier = new Supplier<Integer>() {
       @Override
       public Integer get() {
         throw new NullPointerException();
       }
     };
 
     Supplier<Integer> memoizedSupplier = Suppliers.memoize(exceptingSupplier);
 
     // call get() twice to make sure that memoization doesn't interfere
     // with throwing the exception
     for (int i = 0; i < 2; i++) {
       try {
         memoizedSupplier.get();
         fail("failed to throw NullPointerException");
       } catch (NullPointerException e) {
         // this is what should happen
       }
     }
   }
 
   @GwtIncompatible("Thread.sleep")
   public void testMemoizeWithExpiration() throws InterruptedException {
     CountingSupplier countingSupplier = new CountingSupplier();
 
     Supplier<Integer> memoizedSupplier = Suppliers.memoizeWithExpiration(
         countingSupplier, 75, TimeUnit.MILLISECONDS);
 
     checkExpiration(countingSupplier, memoizedSupplier);
   }
 
   @GwtIncompatible("Thread.sleep, SerializationTester")
   public void testMemoizeWithExpirationSerialized()
       throws InterruptedException {
     CountingSupplier countingSupplier = new CountingSupplier();
 
     Supplier<Integer> memoizedSupplier = Suppliers.memoizeWithExpiration(
         countingSupplier, 75, TimeUnit.MILLISECONDS);
     // Calls to the original memoized supplier shouldn't affect its copy.
     memoizedSupplier.get();
 
     Supplier<Integer> copy = reserialize(memoizedSupplier);
     memoizedSupplier.get();
 
     CountingSupplier countingCopy = (CountingSupplier)
         ((Suppliers.ExpiringMemoizingSupplier<Integer>) copy).delegate;
     checkExpiration(countingCopy, copy);
   }
 
   @GwtIncompatible("Thread.sleep")
   private void checkExpiration(
       CountingSupplier countingSupplier, Supplier<Integer> memoizedSupplier)
       throws InterruptedException {
     // the underlying supplier hasn't executed yet
     assertEquals(0, countingSupplier.calls);
 
     assertEquals(10, (int) memoizedSupplier.get());
     // now it has
     assertEquals(1, countingSupplier.calls);
 
     assertEquals(10, (int) memoizedSupplier.get());
     // it still should only have executed once due to memoization
     assertEquals(1, countingSupplier.calls);
 
     Thread.sleep(150);
 
     assertEquals(20, (int) memoizedSupplier.get());
     // old value expired
     assertEquals(2, countingSupplier.calls);
 
     assertEquals(20, (int) memoizedSupplier.get());
     // it still should only have executed twice due to memoization
     assertEquals(2, countingSupplier.calls);
   }
 
   public void testOfInstanceSuppliesSameInstance() {
     Object toBeSupplied = new Object();
     Supplier<Object> objectSupplier = Suppliers.ofInstance(toBeSupplied);
     assertSame(toBeSupplied,objectSupplier.get());
     assertSame(toBeSupplied,objectSupplier.get()); // idempotent
   }
 
   public void testOfInstanceSuppliesNull() {
     Supplier<Integer> nullSupplier = Suppliers.ofInstance(null);
     assertNull(nullSupplier.get());
   }
 
   @GwtIncompatible("Thread")
 
   public void testExpiringMemoizedSupplierThreadSafe() throws Throwable {
     Function<Supplier<Boolean>, Supplier<Boolean>> memoizer =
         new Function<Supplier<Boolean>, Supplier<Boolean>>() {
       @Override public Supplier<Boolean> apply(Supplier<Boolean> supplier) {
         return Suppliers.memoizeWithExpiration(
             supplier, Long.MAX_VALUE, TimeUnit.NANOSECONDS);
       }
     };
     testSupplierThreadSafe(memoizer);
   }
 
   @GwtIncompatible("Thread")
 
   public void testMemoizedSupplierThreadSafe() throws Throwable {
     Function<Supplier<Boolean>, Supplier<Boolean>> memoizer =
         new Function<Supplier<Boolean>, Supplier<Boolean>>() {
       @Override public Supplier<Boolean> apply(Supplier<Boolean> supplier) {
         return Suppliers.memoize(supplier);
       }
     };
     testSupplierThreadSafe(memoizer);
   }
 
   @GwtIncompatible("Thread")
   public void testSupplierThreadSafe(
       Function<Supplier<Boolean>, Supplier<Boolean>> memoizer)
       throws Throwable {
     final AtomicInteger count = new AtomicInteger(0);
     final AtomicReference<Throwable> thrown =
         new AtomicReference<Throwable>(null);
     final int numThreads = 3;
     final Thread[] threads = new Thread[numThreads];
     final long timeout = TimeUnit.SECONDS.toNanos(60);
 
     final Supplier<Boolean> supplier = new Supplier<Boolean>() {
       boolean isWaiting(Thread thread) {
         switch (thread.getState()) {
           case BLOCKED:
           case WAITING:
           case TIMED_WAITING:
           return true;
           default:
           return false;
         }
       }
 
       int waitingThreads() {
         int waitingThreads = 0;
         for (Thread thread : threads) {
           if (isWaiting(thread)) {
             waitingThreads++;
           }
         }
         return waitingThreads;
       }
 
       @Override
       public Boolean get() {
         // Check that this method is called exactly once, by the first
         // thread to synchronize.
         long t0 = System.nanoTime();
         while (waitingThreads() != numThreads - 1) {
           if (System.nanoTime() - t0 > timeout) {
             thrown.set(new TimeoutException(
                 "timed out waiting for other threads to block" +
                 " synchronizing on supplier"));
             break;
           }
           Thread.yield();
         }
         count.getAndIncrement();
         return Boolean.TRUE;
       }
     };
 
     final Supplier<Boolean> memoizedSupplier = memoizer.apply(supplier);
 
     for (int i = 0; i < numThreads; i++) {
       threads[i] = new Thread() {
         @Override public void run() {
           assertSame(Boolean.TRUE, memoizedSupplier.get());
         }
       };
     }
     for (Thread t : threads) {
       t.start();
     }
     for (Thread t : threads) {
       t.join();
     }
 
     if (thrown.get() != null) {
       throw thrown.get();
     }
     assertEquals(1, count.get());
   }
 
   @GwtIncompatible("Thread")
 
   public void testSynchronizedSupplierThreadSafe()
       throws InterruptedException {
     final Supplier<Integer> nonThreadSafe = new Supplier<Integer>() {
       int counter = 0;
       @Override
       public Integer get() {
         int nextValue = counter + 1;
         Thread.yield();
         counter = nextValue;
         return counter;
       }
     };
 
     final int numThreads = 10;
     final int iterations = 1000;
     Thread[] threads = new Thread[numThreads];
     for (int i = 0; i < numThreads; i++) {
       threads[i] = new Thread() {
         @Override public void run() {
           for (int j = 0; j < iterations; j++) {
             Suppliers.synchronizedSupplier(nonThreadSafe).get();
           }
         }
       };
     }
     for (Thread t : threads) {
       t.start();
     }
     for (Thread t : threads) {
       t.join();
     }
 
     assertEquals(numThreads * iterations + 1, (int) nonThreadSafe.get());
   }
 
   public void testSupplierFunction() {
     Supplier<Integer> supplier = Suppliers.ofInstance(14);
     Function<Supplier<Integer>, Integer> supplierFunction =
         Suppliers.supplierFunction();
 
     assertEquals(14, (int) supplierFunction.apply(supplier));
   }
 
   @GwtIncompatible("SerializationTester")
   public void testSerialization() {
     assertEquals(
         Integer.valueOf(5), reserialize(Suppliers.ofInstance(5)).get());
     assertEquals(Integer.valueOf(5), reserialize(Suppliers.compose(
         Functions.identity(), Suppliers.ofInstance(5))).get());
     assertEquals(Integer.valueOf(5),
         reserialize(Suppliers.memoize(Suppliers.ofInstance(5))).get());
     assertEquals(Integer.valueOf(5),
         reserialize(Suppliers.memoizeWithExpiration(
             Suppliers.ofInstance(5), 30, TimeUnit.SECONDS)).get());
     assertEquals(Integer.valueOf(5), reserialize(
         Suppliers.synchronizedSupplier(Suppliers.ofInstance(5))).get());
   }
 
   @GwtIncompatible("reflection")
   public void testSuppliersNullChecks() throws Exception {
     new ClassSanityTester().forAllPublicStaticMethods(Suppliers.class)
         .testNulls();
   }
 
   @GwtIncompatible("reflection")
   public void testSuppliersSerializable() throws Exception {
     new ClassSanityTester().forAllPublicStaticMethods(Suppliers.class)
         .testSerializable();
   }
 
   public void testOfInstance_equals() {
     new EqualsTester()
         .addEqualityGroup(
             Suppliers.ofInstance("foo"), Suppliers.ofInstance("foo"))
         .addEqualityGroup(Suppliers.ofInstance("bar"))
         .testEquals();
   }
 
   public void testCompose_equals() {
     new EqualsTester()
         .addEqualityGroup(
             Suppliers.compose(Functions.constant(1), Suppliers.ofInstance("foo")),
             Suppliers.compose(Functions.constant(1), Suppliers.ofInstance("foo")))
         .addEqualityGroup(
             Suppliers.compose(Functions.constant(2), Suppliers.ofInstance("foo")))
         .addEqualityGroup(
             Suppliers.compose(Functions.constant(1), Suppliers.ofInstance("bar")))
         .testEquals();
   }
 }